#ifndef __M_SERVER_H__
#define __M_SERVER_H__
#include <iostream>
#include <vector>
#include <assert.h>
#include <string>
#include <cstring>
#include <sys/socket.h>
#include <netinet/in.h> //IPPROTO_TCP
#include <typeinfo>
#include <fcntl.h>
#include <signal.h>
#include <unistd.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <functional>
#include <sys/epoll.h>
#include <unordered_map>
#include <stdlib.h>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <memory>
#include <sys/eventfd.h>
#include <sys/timerfd.h>

#define INF 0
#define DBG 1
#define ERR 2
#define LOG_LEVEL DBG

// 可变参数宏：带时间戳、文件名、行号和格式控制
#define LOG(level, format, ...)                                               \
    do                                                                        \
    {                                                                         \
        if (level < LOG_LEVEL)                                                \
            break;                                                            \
        time_t t = time(NULL);                                                \
        struct tm *local = localtime(&t);                                     \
        char time_str[20];                                                    \
        strftime(time_str, sizeof(time_str), "%H:%M:%S", local);              \
        /* 格式化字符串拼接：固定部分 + 用户传入的format + 换行 */            \
        fprintf(stdout, "[%p %s %s:%d] " format "\n", (void *)pthread_self(), \
                time_str, __FILE__, __LINE__, ##__VA_ARGS__);                 \
    } while (0)

#define INF_LOG(format, ...) LOG(INF, format, ##__VA_ARGS__)
#define DBG_LOG(format, ...) LOG(DBG, format, ##__VA_ARGS__)
#define ERR_LOG(format, ...) LOG(ERR, format, ##__VA_ARGS__)

#define BUFFER_DEFAULT_SIZE 1024
class Buffer // 缓冲区
{
private:
    std::vector<char> _buffer; // 使用vector进行内存空间管理
    uint64_t _write_index;     // 写偏移
    uint64_t _read_index;

public:
    Buffer() : _buffer(BUFFER_DEFAULT_SIZE), _write_index(0), _read_index(0) {}
    char *Begin() // 获得起始地址
    {
        return &*_buffer.begin();
    }
    char *WritePosition() // 可写地址
    {
        return Begin() + _write_index;
    }
    char *ReadPosition() // 可读地址
    {
        return Begin() + _read_index;
    }
    // 获取缓冲区末尾空闲空间大小--写偏移之后的空闲空间, 总体空间大小减去写偏移
    uint64_t TailIdleSize() { return _buffer.size() - _write_index; }
    // 获取缓冲区起始空闲空间大小--读偏移之前的空闲空间
    uint64_t HeadIdleSize() { return _read_index; }
    // 获取可读数据大小 = 写偏移 - 读偏移
    uint64_t ReadAbleSize() { return _write_index - _read_index; }
    //
    void ReadMoveOffset(uint64_t len) // 读偏移后移
    {
        if (len == 0)
            return;
        // 向后移动的大小，必须小于可读数据大小
        assert(len <= ReadAbleSize());
        _read_index += len;
    }
    void WriteMoveOffset(uint64_t len) // 写偏移后移
    {
        // 后面空闲的大于写入长度，写偏移后移len
        assert(len <= TailIdleSize());
        _write_index += len;
    }
    // 确保可写空间足够（整体空闲空间够了就移动数据，否则就扩容）
    void EnsureWriteSpace(uint64_t len)
    {
        if (TailIdleSize() >= len)
            return;
        if (TailIdleSize() + HeadIdleSize() >= len)
        {
            uint64_t rsz = ReadAbleSize();                            // 把当前数据大小先保存起来
            std::copy(ReadPosition(), ReadPosition() + rsz, Begin()); // 把可读数据拷贝到起始位置
            _read_index = 0;
            _write_index = rsz;
        }
        else
        {
            std::cout << "满了" << std::endl;
            _buffer.resize(_write_index + len);
        }
    }
    // 写数据
    void Write(const void *data, uint64_t len)
    {
        if (len == 0)
            return;
        EnsureWriteSpace(len);
        const char *d = (const char *)data;
        std::copy(d, d + len, WritePosition());
    }
    void WriteAndPush(const void *data, uint64_t len)
    {
        Write(data, len);
        WriteMoveOffset(len);
    }
    // 写字符串
    void WriteString(const std::string &data)
    {
        return Write(data.c_str(), data.size());
    }
    void WriteStringAndPush(const std::string &data)
    {
        WriteString(data);
        WriteMoveOffset(data.size());
    }
    // 写其他缓冲区到这
    void WriteBuffer(Buffer &other)
    {
        return Write(other.ReadPosition(), other.ReadAbleSize());
    }
    void WriteBufferAndPush(Buffer &other)
    {
        WriteBuffer(other);
        WriteMoveOffset(other.ReadAbleSize());
    }
    void Read(void *buf, uint64_t len)
    {
        // 要求要获取的数据大小必须小于可读数据大小
        assert(len <= ReadAbleSize());
        std::copy(ReadPosition(), ReadPosition() + len, (char *)buf);
    }
    void ReadAndPop(void *buf, uint64_t len)
    {
        Read(buf, len);
        ReadMoveOffset(len);
    }
    std::string ReadString(uint64_t len)
    {
        assert(len <= ReadAbleSize());
        std::string str;
        str.resize(len);
        Read(&str[0], len); // 不用str.c_str(返回的是const char*，没法修改
        return str;
    }
    std::string ReadStringAndPop(uint64_t len)
    {
        std::string str = ReadString(len);
        ReadMoveOffset(len);
        return str;
    }

    char *FindCRLF()
    {
        // memchr是函数，查找
        char *res = (char *)memchr(ReadPosition(), '\n', ReadAbleSize());
        return res;
    }
    /*通常获取一行数据，这种情况针对是*/
    std::string GetLine()
    {
        char *pos = FindCRLF();
        if (pos == NULL)
        {
            return "";
        }
        // +1是为了把换行字符也取出来。
        return ReadString(pos - ReadPosition() + 1);
    }
    std::string GetLineAndPop()
    {
        std::string str = GetLine();
        ReadMoveOffset(str.size());
        return str;
    }

    void Clear()
    {
        // 清零，后续覆盖写入
        _read_index = 0;
        _write_index = 0;
    }
};

#define MAX_LISTEN 1024
class Socket
{
private:
    int _sockfd;     // 监听
    uint64_t _port;  // 端口
    std::string _ip; //;ip
public:
    Socket() {}
    Socket(int fd) : _sockfd(fd) {}
    ~Socket() {}
    // 创建套接字
    bool Create()
    {
        _sockfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        if (_sockfd < 0)
        {
            ERR_LOG("Create sockfd error");
            return false;
        }
        return true;
    }
    // 绑定
    bool Bind(uint64_t port, std::string ip)
    {
        struct sockaddr_in temp;
        temp.sin_family = AF_INET;
        temp.sin_addr.s_addr = inet_addr(ip.c_str());
        temp.sin_port = htons(port);
        socklen_t len = sizeof(temp);
        if (bind(_sockfd, (struct sockaddr *)&temp, len) < 0)
        {
            ERR_LOG("Bind error");
            return false;
        }
        return true;
    }
    // 监听
    bool Listen(int backlog = MAX_LISTEN)
    {
        // 此时并发最大连接数
        if (listen(_sockfd, backlog) < 0)
        {
            ERR_LOG("listen error");
            return false;
        }
        return true;
    }
    // 向服务器发起连接
    bool Connect(const std::string &ip, uint16_t port)
    {
        struct sockaddr_in temp; // 服务器ip和端口
        temp.sin_family = AF_INET;
        temp.sin_addr.s_addr = inet_addr(ip.c_str());
        temp.sin_port = htons(port);
        socklen_t len = sizeof(temp);
        if (connect(_sockfd, (struct sockaddr *)&temp, len) < 0)
        {
            ERR_LOG("Connect error ");
            return false;
        }
        return true;
    }
    // 连接
    int Accept() //(uint64_t &port, std::string &clientip)
    {
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        int newfd = accept(_sockfd, (struct sockaddr *)&peer, &len);
        if (newfd < 0)
        {
            ERR_LOG("Accept error");
            return -1;
        }
        // char ipstr[64];
        // inet_ntop(AF_INET, &peer.sin_addr, ipstr, sizeof(ipstr));
        // clientip = ipstr;
        // port = ntohs(peer.sin_port);
        return newfd;
    }
    // 接收数据
    ssize_t Recv(void *buff, size_t len, int flag = 0)
    {
        ssize_t ret = recv(_sockfd, buff, len, flag);
        if (ret <= 0)
        {
            // EAGAIN 当前socket的接收缓冲区中没有数据了，在非阻塞的情况下才会有这个错误
            // EINTR  表示当前socket的阻塞等待，被信号打断了，
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0; // 表示这次接收没有接收到数据
            }
            ERR_LOG("SOCKET RECV FAILED!!");
            return -1;
        }
        std::cout << (char *)buff << std::endl;
        return ret; // 实际接收的数据长度
    }
    ssize_t NonBlockRecv(void *buf, size_t len)
    {
        return Recv(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接收为非阻塞。
    }
    // 发送数据
    ssize_t Send(const void *buff, size_t len, int flag = 0) // s.c_str()是const void*
    {
        ssize_t ret = send(_sockfd, buff, len, flag);
        if (ret < 0)
        {
            if (errno == EAGAIN || errno == EINTR)
            {
                return 0;
            }
            ERR_LOG("SOCKET SEND FAILED!!");
            return -1;
        }
        return ret; // 实际发送的数据长度
    }
    ssize_t NonBlockSend(void *buf, size_t len) // 设置非阻塞
    {
        if (len == 0)
            return 0;
        return Send(buf, len, MSG_DONTWAIT); // MSG_DONTWAIT 表示当前接收为非阻塞。
    }
    // 创建一个服务端连接
    bool CreateServer(uint64_t port, const std::string ip = "0.0.0.0", bool flag = false) // 是否启动非阻塞前期测试)
    {
        if (Create() == false)
            return false;
        ReuseAddres(); // 2. 先设置端口复用（关键！）,后绑定
        if (flag)
        {
            NonBolck();
        }
        if (Bind(port, ip) == false)
            return false;
        if (Listen() == false)
            return false;
        return true;
    }
    // 创建客户端连接
    bool CreatClient(uint64_t port, std::string ip)
    {
        if (Create() == false)
            return false;
        if (Connect(ip, port) == false)
            return false;
        return true;
    }
    // 设置套接字非阻塞以及地址端口立即启用
    void NonBolck()
    {
        int flag = fcntl(_sockfd, F_GETFL, 0);
        fcntl(_sockfd, F_SETFL, flag | O_NONBLOCK);
    }

    void ReuseAddres()
    {
        // int setsockopt(int fd, int leve, int optname, void *val, int vallen)
        int val = 1;
        // 设置 SO_REUSEADDR
        if (setsockopt(_sockfd, SOL_SOCKET, SO_REUSEADDR, &val, sizeof(val)) == -1)
        {
            perror("setsockopt SO_REUSEADDR failed");
            // 处理错误（如关闭套接字、退出等）
        }
        val = 1;
        // 设置 SO_REUSEPORT
        if (setsockopt(_sockfd, SOL_SOCKET, SO_REUSEPORT, &val, sizeof(val)) == -1)
        {
            perror("setsockopt SO_REUSEPORT failed");
            // 处理错误
        }
    }
    int Fd()
    {
        return _sockfd;
    }
    void Close()
    {
        close(_sockfd);
    }
};
class Poller;
class Eventloop;
class Channel
{
private:
    int _fd; // Poller *_poller;
    Eventloop *_loop;
    uint32_t _events;  // 当前需要监控的事件
    uint32_t _revents; // 当前连接触发的事件
    using EventCallback = std::function<void()>;
    EventCallback _read_callback;  // 可读事件被触发的回调函数
    EventCallback _write_callback; // 可写事件被触发的回调函数
    EventCallback _error_callback; // 错误事件被触发的回调函数
    EventCallback _close_callback; // 连接断开事件被触发的回调函数
    EventCallback _event_callback; // 任意事件被触发的回调函数
public:
    Channel() {}
    Channel(int fd, Eventloop *loop) : _fd(fd), _events(0), _revents(0), _loop(loop) {}
    int Fd() { return _fd; }
    uint32_t Events() { return _events; }                   // 获取想要监控的事件
    void SetREvents(uint32_t events) { _revents = events; } // 设置实际就绪的事件
    void SetReadCallback(const EventCallback &cb) { _read_callback = cb; }
    void SetWriteCallback(const EventCallback &cb) { _write_callback = cb; }
    void SetErrorCallback(const EventCallback &cb) { _error_callback = cb; }
    void SetCloseCallback(const EventCallback &cb) { _close_callback = cb; }
    void SetEventCallback(const EventCallback &cb) { _event_callback = cb; }
    // 当前是否监控了可读
    bool ReadAble() { return (_events & EPOLLIN); }
    // 当前是否监控了可写
    bool WriteAble() { return (_events & EPOLLOUT); }
    // 启动读事件监控
    void EnableRead()
    {
        _events |= EPOLLIN;
        Update();
    }
    // 启动写事件监控
    void EnableWrite()
    {
        _events |= EPOLLOUT;
        Update();
    }
    // 关闭读事件监控
    void DisableRead()
    {
        _events &= ~EPOLLIN;
        Update();
    }
    // 关闭写事件监控
    void DisableWrite()
    {
        _events &= ~EPOLLOUT;
        Update();
    }
    // 关闭所有事件监控
    void DisableAll()
    {
        _events = 0;
        Update();
    }
    // 移除监控
    void Remove();
    void Update();
    // 事件处理，一旦连接触发了事件，就调用这个函数，自己触发了什么事件如何处理自己决定
    void HandleEvent()
    {
        // if (_event_callback)
        //     _event_callback();
        if ((_revents & EPOLLIN) || (_revents & EPOLLRDHUP) || (_revents & EPOLLPRI))
        {
            /*不管任何事件，都调用的回调函数*/
            if (_read_callback)
                _read_callback();
        }
        /*有可能会释放连接的操作事件，一次只处理一个*/
        if (_revents & EPOLLOUT)
        {
            if (_write_callback)
                _write_callback();
        }
        else if (_revents & EPOLLERR)
        {
            if (_error_callback)
                _error_callback(); // 一旦出错，就会释放连接，因此要放到前边调用任意回调
        }
        else if (_revents & EPOLLHUP)
        {
            if (_close_callback)
                _close_callback();
        }
         if (_event_callback)
            _event_callback();
    }
};
#define MAX_EPOLLEVENTS 1024
class Poller
{
private:
    int _epfd;
    struct epoll_event revents[MAX_EPOLLEVENTS];
    std::unordered_map<int, Channel *> _channels;

private:
    // 对EPOLL操作
    void Update(Channel *channel, int op)
    {
        int fd = channel->Fd();
        struct epoll_event ev;
        ev.data.fd = fd;
        ev.events = channel->Events();
        int ret = epoll_ctl(_epfd, op, fd, &ev);
        if (ret < 0)
        {
            ERR_LOG("EPOLL ERROR ");
            // abort();
        }
    }
    // 判断一个Channel是否已经添加了事件监控
    bool HasChannel(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it == _channels.end())
        {
            return false;
        }
        return true;
    }

public:
    Poller()
    {
        _epfd = epoll_create(MAX_EPOLLEVENTS);
        if (_epfd < 0)
        {
            ERR_LOG("EPOLL CREATE FAILED!!");
            abort(); // 退出程序
        }
    }
    // 添加或修改事件监控
    void UpdateEvent(Channel *channel)
    {
        if (!HasChannel(channel))
        {
            _channels.insert(std::make_pair(channel->Fd(), channel));
            return Update(channel, EPOLL_CTL_ADD);
        }
        return Update(channel, EPOLL_CTL_MOD);
    }
    // 移除事件监控
    void Remove(Channel *channel)
    {
        auto it = _channels.find(channel->Fd());
        if (it != _channels.end())
        {
            _channels.erase(it);
            // close(channel->Fd());
            // std::cout<<"移除"<<std::endl;
        }
        return Update(channel, EPOLL_CTL_DEL);
    }
    // 开始监控，返回活跃连接
    void Poll(std::vector<Channel *> *active)
    {
        active->clear();                                         // 强制清空传入的向量，避免任何残留
        int n = epoll_wait(_epfd, revents, MAX_EPOLLEVENTS, -1); // 设置阻塞
        if (n < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            ERR_LOG("EPOLL WAIT ERROR:%s\n", strerror(errno));
            abort(); // 退出程序
        }
        for (int i = 0; i < n; i++)
        {
            auto it = _channels.find(revents[i].data.fd);
            assert(it != _channels.end());
            active->push_back(it->second);
            it->second->SetREvents(revents[i].events);
        }
        return;
    }
};
class Eventloop;
using TaskFunc = std::function<void()>;
using ReleaseFunc = std::function<void()>;
class Timetask
{
public:
    Timetask(uint64_t id, int timeout, const TaskFunc &cb) : _id(id), _timeout(timeout), _cb(cb), cmz(false)
    {
    }
    ~Timetask()
    {
        if (cmz == false)
            _cb();
        _release();
    }
    void Cancel() { cmz = true; }
    void SetRelease(const ReleaseFunc &release)
    {
        _release = release;
    }
    int Delaytime()
    {
        return _timeout;
    }

private:
    uint64_t _id;         // 定时器任务对象id
    int _timeout;         // 超时时间
    TaskFunc _cb;         // 超时执行任务
    bool cmz;             // false表是没取消，true取消了
    ReleaseFunc _release; // 用于删除TimerWheel中保存的定时器对象信息,指针彻底释放完后
};
class Eventloop;
class Timewheel
{
private:
    using Weaktask = std::weak_ptr<Timetask>;
    using Ptrtask = std::shared_ptr<Timetask>;
    int tick;      // 秒钟
    int _capacity; // 表盘最大数量，最大延迟时间
    std::vector<std::vector<Ptrtask>> _wheel;
    std::unordered_map<uint64_t, Weaktask> _timers;
    int _timerfd;
    Eventloop *_loop;
    std::unique_ptr<Channel> _timerfd_channel;

private:
    void Remove(uint64_t id) // 移除
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return;
        }
        _timers.erase(it);
    }

public:
    static int CreadteTimerfd()
    {
        int timerfd = timerfd_create(CLOCK_MONOTONIC, 0);
        if (timerfd < 0)
        {
            ERR_LOG("TIMERFD CREATE FAILED!");
            abort();
        }
        // int timerfd_settime(int fd, int flags, struct itimerspec *new, struct itimerspec *old);
        struct itimerspec itime;
        itime.it_value.tv_sec = 1;
        itime.it_value.tv_nsec = 0; // 第一次超时时间为1s后
        itime.it_interval.tv_sec = 1;
        itime.it_interval.tv_nsec = 0; // 第一次超时后，每次超时的间隔时
        timerfd_settime(timerfd, 0, &itime, NULL);
        return timerfd;
    }
    int ReadTimefd()
    {
        uint64_t times;
        // 有可能因为其他描述符的事件处理花费事件比较长，然后在处理定时器描述符事件的时候，有可能就已经超时了很多次
        // read读取到的数据times就是从上一次read之后超时的次数
        int ret = read(_timerfd, &times, 8);
        if (ret < 0)
        {
            ERR_LOG("READ TIMEFD FAILED!");
            abort();
        }
        return times;
    }
    void RunTimerTask()
    {
        tick = (tick + 1) % _capacity;
        _wheel[tick].clear(); // 清空指定位置的数组，就会把数组中保存的所有管理定时器对象的shared_ptr释放掉
    }
    // void OnTime()
    // {
    //     ReadTimefd();
    //     RunTimerTask();
    // }
    void OnTime() 
    {
        //根据实际超时的次数，执行对应的超时任务
        int times = ReadTimefd();
        for (int i = 0; i < times; i++) 
        {
            RunTimerTask();
        }
    }
    void TimeAddInloop(uint64_t id, int timeout, const TaskFunc &cb)
    {
        Ptrtask pt(new Timetask(id, timeout, cb));
        pt->SetRelease(std::bind(&Timewheel::Remove, this, id));
        _timers[id] = Weaktask(pt);

        int pos = (tick + timeout) % _capacity;
        _wheel[pos].push_back(pt);
    }
    void TimeRefreshInloop(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return; // 没有定时任务，不刷新
        }
        Ptrtask pt = it->second.lock(); // weak_ptr转为shared_ptr
        int timeout = pt->Delaytime();
        int pos = (tick + timeout) % _capacity;
        _wheel[pos].push_back(pt);
    }
    void TimeCancelInloop(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return;
        }
        Ptrtask pt = it->second.lock();
        if (pt)
            pt->Cancel();
    }

public:
    Timewheel(Eventloop *loop, int t = 0, int capacity = 60) : tick(0), _capacity(capacity), _wheel(_capacity), _timerfd(CreadteTimerfd()), _loop(loop), _timerfd_channel(new Channel(_timerfd, _loop))
    {
        _timerfd_channel->SetReadCallback(std::bind(&Timewheel::OnTime, this));
        _timerfd_channel->EnableRead();
    }
    void TimerAdd(uint64_t id, int timeout, const TaskFunc &cb); // Eventloop向前定义没法用函数，函数在下面实现
    // {
    //     return _loop->RunInloop(std::bind(&Timewheel::TimeAddInloop,this,id,timeout,cb));
    // }
    void TimerRefresh(uint64_t id);
    // {
    //     return _loop->RunInloop(std::bind(&Timewheel::TimeRefreshInloop,this,id));
    // }
    void TimerCancel(uint64_t id);
    // {
    //     return _loop->RunInloop(std::bind(&Timewheel::TimeCancelInloop,this,id));
    // }
    bool HasTimer(uint64_t id)
    {
        auto it = _timers.find(id);
        if (it == _timers.end())
        {
            return false;
        }
        return true;
    }
};
class Eventloop
{
private:
    using Functor = std::function<void()>;
    std::thread::id _thread_id; // 线程ID
    int _event_fd;              // eventfd唤醒IO事件监控有可能导致的阻塞
    std::unique_ptr<Channel> _event_channel;
    Poller _poller;              // 进行所有描述符的事件监控
    std::vector<Functor> _tasks; // 任务池
    std::mutex _mutex;           // 实现任务池操作的线程安全

    Timewheel _timewheel; // 引入定时器模块

public:
    // 执行任务
    void RunAllTask()
    {
        std::vector<Functor> functor;
        {
            std::unique_lock<std::mutex> _lock(_mutex);
            _tasks.swap(functor);
        }
        for (auto &f : functor)
        {
            f();
        }
        return;
    }
    static int CreateEventfd()
    {
        int efd = eventfd(0, EFD_CLOEXEC | EFD_NONBLOCK);
        if (efd < 0)
        {
            ERR_LOG("CREATE EVENTFD FAILED!!");
            abort(); // 让程序异常退出
        }
        return efd;
    }
    void ReadEventfd()
    {
        uint64_t res = 0;
        int ret = read(_event_fd, &res, sizeof(res));
        if (ret < 0)
        {
            // EINTR -- 被信号打断；   EAGAIN -- 表示无数据可读
            if (errno == EINTR || errno == EAGAIN)
            {
                return;
            }
            ERR_LOG("READ EVENTFD FAILED!");
            abort();
        }
        return;
    }
    void WeakUpEventFd()
    {
        uint64_t val = 1;
        int ret = write(_event_fd, &val, sizeof(val));
        if (ret < 0)
        {
            if (errno == EINTR)
            {
                return;
            }
            ERR_LOG("READ EVENTFD FAILED!");
            abort();
        }
        return;
    }

public:
    Eventloop() : _thread_id(std::this_thread::get_id()), _event_fd(CreateEventfd()), _event_channel(new Channel(_event_fd, this)), _timewheel(this)
    {
        // 给eventfd添加可读事件回调函数，读取eventfd事件通知次数
        _event_channel->SetReadCallback(std::bind(&Eventloop::ReadEventfd, this));
        // 启动eventfd的读事件监控
        _event_channel->EnableRead();
    }
    // 三步走--事件监控-》就绪事件处理-》执行任务
    void Start()
    {
        while (1)
        {
            // 开始监控
            std::vector<Channel *> actives;
            _poller.Poll(&actives);
            // 2. 事件处理。
            for (auto &a : actives)
            {
                a->HandleEvent();
            }
            // 3执行任务
            RunAllTask();
        }
    }
    // 判断是不是当前线程的
    bool Isloop()
    {
        return std::this_thread::get_id() == _thread_id;
    }
    void AssertInloop()
    {
        assert(std::this_thread::get_id() == _thread_id);
    }
    // 是本线程任务直接执行
    void RunInloop(const Functor &cb)
    {
        if (Isloop())
        {
            return cb();
        }
        return QueueTask(cb);
    }
    // 不是压入任务队列
    void QueueTask(const Functor &cb)
    {
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _tasks.push_back(cb);
        }
        // 唤醒有可能因为没有事件就绪，而导致的epoll阻塞；
        // 其实就是给eventfd写入一个数据，eventfd就会触发可读事件
        WeakUpEventFd();
        return;
    }
    void RemoveEvent(Channel *channel) { return _poller.Remove(channel); }      // 对事件监控移除
    void UpdateEvent(Channel *channel) { return _poller.UpdateEvent(channel); } // 添加或者修改

    void TimerAdd(uint64_t id, uint32_t delay, const TaskFunc &cb) { return _timewheel.TimerAdd(id, delay, cb); }
    void TimerRefresh(uint64_t id) { return _timewheel.TimerRefresh(id); }
    void TimerCancel(uint64_t id) { return _timewheel.TimerCancel(id); }
    bool HasTimer(uint64_t id) { return _timewheel.HasTimer(id); }
};

class Any
{
private:
    class holder
    {
    public:
        virtual ~holder() {}
        virtual const std::type_info &type() = 0;
        virtual holder *clone() = 0;
    };
    template <class T>
    class placeholder : public holder
    {
    public:
        placeholder(const T &val) : _val(val) {}
        // 获取子类对象保存的数据类型
        virtual const std::type_info &type() { return typeid(T); }
        // 针对当前的对象自身，克隆出一个新的子类对象
        virtual holder *clone() { return new placeholder(_val); }

    public:
        T _val;
    };
    holder *_content;

public:
    Any() : _content(NULL) {}
    template <class T>
    Any(const T &val) : _content(new placeholder<T>(val)) {}
    Any(const Any &other) : _content(other._content ? other._content->clone() : NULL) {}
    ~Any() { delete _content; }
    Any &swap(Any &other)
    {
        std::swap(_content, other._content);
        return *this;
    }
    // 返回子类对象保存的数据的指针
    template <class T>
    T *get()
    {
        // 想要获取的数据类型，必须和保存的数据类型一致
        assert(typeid(T) == _content->type());
        return &((placeholder<T> *)_content)->_val;
    }
    // 赋值运算符的重载函数
    template <class T>
    Any &operator=(const T &val)
    {
        // 为val构造一个临时的通用容器，然后与当前容器自身进行指针交换，临时对象释放的时候，原先保存的数据也就被释放
        Any(val).swap(*this);
        return *this;
    }
    Any &operator=(const Any &other)
    {
        Any(other).swap(*this);
        return *this;
    }
};
class Threadloop // 线程和eventloop联合
{
private:
    /*用于实现_loop获取的同步关系，避免线程创建了，但是_loop还没有实例化之前去获取_loop*/
    std::condition_variable _cond; // 跳进变量
    std::mutex _mutex;
    Eventloop *_loop;
    std::thread _thread; // EventLoop对应的线程
private:
    void ThreadEntry() // 线程函数入口
    {
        Eventloop loop;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _loop = &loop;
            _cond.notify_all();
        }
        loop.Start();
    }

public:
    Threadloop() : _loop(nullptr), _thread(std::thread(&Threadloop::ThreadEntry, this)) {}
    Eventloop *Getloop() // 主线程获取子线程的loop
    {
        Eventloop *loop = nullptr;
        {
            std::unique_lock<std::mutex> lock(_mutex);
            _cond.wait(lock, [&]()
                       { return _loop != nullptr; });
            loop = _loop;
        }
        return loop;
    }
};

// 核心功能：统一管理从 Reactor 线程的 EventLoop
// 线程池初始化：通过 Create() 方法创建指定数量的 LoopThread（从 Reactor 线程），并提前获取每个线程的 EventLoop 指针，存储在 _loops 中
// 。这样后续分配时无需再阻塞等待 EventLoop 初始化（LoopThread::GetLoop() 已通过条件变量确保 EventLoop 就绪）。
// 连接分配：NextLoop() 是核心接口，通过 _next_idx 实现 RR 轮转，每次返回下一个从 Reactor 的 EventLoop，保证新连接在从线程间平均分配。
// 降级处理：若 _thread_count == 0（未创建从线程），直接返回主线程的 _baseloop，确保框架在单线程模式下也能正常工作。
class ThreadloopPool
{
private:
    int _thread_count;    // 创建从reactor线程数量
    int _next_index;      // 下一个的索引
    Eventloop *_baseloop; // 主线程
    std::vector<Threadloop *> _threads;
    std::vector<Eventloop *> _loops;

public:
    ThreadloopPool(Eventloop *baseloop) : _thread_count(0), _next_index(0), _baseloop(baseloop) {}
    void SetThreadCount(int count) { _thread_count = count; }
    void Create()
    {
        // 记得申请不然段错误越界访问
        _threads.resize(_thread_count);
        _loops.resize(_thread_count);
        for (int i = 0; i < _thread_count; i++)
        {
            _threads[i] = new Threadloop();
            _loops[i] = _threads[i]->Getloop();
        }
    }
    Eventloop *Nextloop()
    {
        if (_thread_count == 0)
        {
            return _baseloop;
        }
        _next_index = (_next_index + 1) % _thread_count;
        return _loops[_next_index];
    }
};
class Connection;
// DISCONECTED -- 连接关闭状态；   CONNECTING -- 连接建立成功-待处理状态
// CONNECTED -- 连接建立完成，各种设置已完成，可以通信的状态；  DISCONNECTING -- 待关闭状态
typedef enum
{
    DISCONNECTED,
    CONNECTING,
    CONNECTED,
    DISCONNECTING
} ConnStatu;
using PtrConnection = std::shared_ptr<Connection>;
class Connection : public std::enable_shared_from_this<Connection>
{
private:
    uint64_t _conn_id; // 连接的唯一ID，便于连接的管理和查找
    // uint64_t _timer_id;   //定时器ID，是唯一的,使用conn_id作为定时器ID
    int _sockfd;                   // 连接关联的文件描述符
    bool _enable_inactive_release; // 连接是否启动非活跃销毁的判断标志，默认为false
    Eventloop *_loop;              // 连接所关联的一个EventLoop
    ConnStatu _statu;              // 连接状态
    Socket _socket;                // 套接字操作管理
    Channel _channel;              // 连接的事件管理
    Buffer _in_buffer;             // 输入缓冲区---存放从socket中读取到的数据
    Buffer _out_buffer;            // 输出缓冲区---存放要发送给对端的数据
    Any _context;                  // 请求的接收处理上下文

    /*这四个回调函数，是让服务器模块来设置的（其实服务器模块的处理回调也是组件使用者设置的）*/
    /*换句话说，这几个回调都是组件使用者使用的*/
    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
    /*组件内的连接关闭回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭*/
    /*就应该从管理的地方移除掉自己的信息*/
    ClosedCallback _server_closed_callback;

private:
    /*五个channel的事件回调函数*/
    // 描述符可读事件触发后调用的函数，接收socket数据放到接收缓冲区中，然后调用_message_callback
    void HandleRead()
    {
        char buf[65536];
        ssize_t ret = _socket.NonBlockRecv(buf, 65535);
        if (ret < 0)
        {
            // 区分错误类型：ECONNRESET 是客户端正常关闭，其他是真错误
            if (errno == ECONNRESET)
            {
                return Release(); // 客户端正常关闭，直接释放连接
            }
            // 出错了,不能直接关闭连接
            return ShutdownInloop();
        }
        // 这里的等于0表示的是没有读取到数据，而并不是连接断开了，连接断开返回的是-1
        // 将数据放入输入缓冲区,写入之后顺便将写偏移向后移动
        _in_buffer.WriteAndPush(buf, ret);
        // 2. 调用message_callback进行业务处理
        if (_in_buffer.ReadAbleSize() > 0)
        {
            // shared_from_this--从当前对象自身获取自身的shared_ptr管理对象
            return _message_callback(shared_from_this(), &_in_buffer);
        }
    }
    // 描述符可写事件触发后调用的函数，将发送缓冲区中的数据进行发送
    void HandleWrite()
    {
        ssize_t ret = _socket.NonBlockSend(_out_buffer.ReadPosition(), _out_buffer.ReadAbleSize());
        if (ret < 0)
        {
            if (_in_buffer.ReadAbleSize() > 0)
            {
                _message_callback(shared_from_this(), &_in_buffer);
            }
            return Release();
        }
        _out_buffer.ReadMoveOffset(ret);
        if (_out_buffer.ReadAbleSize() == 0)
        {
            _channel.DisableWrite();
            if (_statu == DISCONNECTING)
            {
                return Release();
            }
        }
        return;
    }
    // 描述符触发挂断事件
    void HandleClose()
    {
        if (_in_buffer.ReadAbleSize() > 0)
        {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        return Release();
    }
    // 描述符触发出错事件
    void HandleError()
    {
        return HandleClose();
    }
    // 描述符触发任意事件: 1. 刷新连接的活跃度--延迟定时销毁任务；  2. 调用组件使用者的任意事件回调
    void HandleEvent()
    {
        if (_enable_inactive_release == true)
        {
            _loop->TimerRefresh(_conn_id);
        }
        if (_event_callback)
        {
            _event_callback(shared_from_this());
        }
    }
    // 连接获取之后，所处的状态下要进行各种设置（启动读监控,调用回调函数）
    void EstablishedInloop()
    {
        assert(_statu == CONNECTING);
        _statu = CONNECTED;
        _channel.EnableRead();
        if (_connected_callback)
            _connected_callback(shared_from_this());
    }
    void ReleaseInloop() // 实际释放接口
    {
        // 1. 修改连接状态，将其置为DISCONNECTED
        _statu = DISCONNECTED;
        // 2. 移除连接的事件监控
        _channel.Remove();
        // 3. 关闭描述符
        _socket.Close();
        // 4. 如果当前定时器队列中还有定时销毁任务，则取消任务
        if (_loop->HasTimer(_conn_id))
        {
            CancelInactiveRelease();
        }
        // 5. 调用关闭回调函数，避免先移除服务器管理的连接信息导致Connection被释放，再去处理会出错，因此先调用用户的回调函数
        if (_closed_callback)
            _closed_callback(shared_from_this());
        // 移除服务器内部管理的连接信息
        if (_server_closed_callback)
            _server_closed_callback(shared_from_this());
    }
    void SendInloop(Buffer buf) // 发送数据外部接口，实际内部调用在loop里，线程安全
    {
        if (_statu == DISCONNECTED)
            return;
        _out_buffer.WriteBufferAndPush(buf);
        if (_channel.WriteAble() == false)
        {
            _channel.EnableWrite();
        }
    }
    // 这个关闭操作并非实际的连接释放操作，需要判断还有没有数据待处理，待发送
    void ShutdownInloop()
    {
        _statu = DISCONNECTING; // 半关闭
        if (_in_buffer.ReadAbleSize() > 0)
        {
            _message_callback(shared_from_this(), &_in_buffer);
        }
        if (_out_buffer.ReadAbleSize() > 0)
        {
            if (_channel.WriteAble() == false)
            {
                _channel.EnableWrite();
            }
        }
        //ctrl+c，直接关闭不一致发送
        if (_out_buffer.ReadAbleSize() == 0)
        {
            Release();
        }
        return;
    }
    void EnableInactiveReleaseInloop(int timeout) // 启动超时非活跃销毁
    {
        // 1. 将判断标志 _enable_inactive_release 置为true
        _enable_inactive_release = true;
        // 当前id任务存在就刷新，不在新增
        if (_loop->HasTimer(_conn_id))
        {
            return _loop->TimerRefresh(_conn_id);
        }
        _loop->TimerAdd(_conn_id, timeout, std::bind(&Connection::Release, this));
    }
    void CancelInactiveReleaseInloop() // 关闭
    {
        _enable_inactive_release = false;
        if (_loop->HasTimer(_conn_id))
        {
            _loop->TimerCancel(_conn_id);
        }
    }
    void ChangeProtoclInlopp(const Any &context, ConnectedCallback &cn, ClosedCallback &cb, MessageCallback &mc, AnyEventCallback &ac) // 协议切换
    {
        _context = context;
        _connected_callback = cn;
        _closed_callback = cb;
        _message_callback = mc;
        _event_callback = ac;
    }

public:
    Connection(Eventloop *loop, uint64_t conn_id, int sockfd) : _conn_id(conn_id), _sockfd(sockfd), _enable_inactive_release(false), _loop(loop), _statu(CONNECTING), _socket(_sockfd), _channel(_sockfd, _loop)
    {
        _channel.SetReadCallback(std::bind(&Connection::HandleRead, this));
        _channel.SetWriteCallback(std::bind(&Connection::HandleWrite, this));
        _channel.SetCloseCallback(std::bind(&Connection::HandleClose, this));
        _channel.SetErrorCallback(std::bind(&Connection::HandleError, this));
        _channel.SetEventCallback(std::bind(&Connection::HandleEvent, this));
    }
    ~Connection() { DBG_LOG("RELEASE CONNECTION:%p", this); }
    int Fd() { return _sockfd; }
    int Id() { return _conn_id; }
    bool IsConnected() { return _statu == CONNECTED; }
    void SetContext(const Any &context) { _context = context; }
    Any *Getcontext() { return &_context; }

    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    void SetSrvClosedCallback(const ClosedCallback &cb) { _server_closed_callback = cb; }

    // 连接建立就绪后，进行channel回调设置，启动读监控，调用_connected_callback
    void Established() { return _loop->RunInloop(std::bind(&Connection::EstablishedInloop, this)); }
    void Send(const char *data, size_t len) // 发送数据外部接口，实际内部调用在loop里，线程安全
    {
        // 外界传入的data，可能是个临时的空间，我们现在只是把发送操作压入了任务池，有可能并没有被立即执行
        // 因此有可能执行的时候，data指向的空间有可能已经被释放了。
        Buffer buf;
        buf.WriteAndPush(data, len);
        return _loop->RunInloop(std::bind(&Connection::SendInloop, this, buf));
    }
    void Shutdown() // 给用户的关闭连接接口，实际不关检查数据
    {
        _loop->RunInloop(std::bind(&Connection::ShutdownInloop, this));
    }
    // void Release()
    // {
    //     _loop->RunInloop(std::bind(&Connection::ReleaseInloop, this));
    // }
    void Release()
    {
        _loop->QueueTask(std::bind(&Connection::ReleaseInloop,this));
    }
    void EnableInactiveRelease(int time) // 启动超时非活跃销毁,定义多长时间无通信非活跃，添加定时任务
    {
        _loop->RunInloop(std::bind(&Connection::EnableInactiveReleaseInloop, this, time));
    }
    void CancelInactiveRelease() // 关闭
    {
        _loop->RunInloop(std::bind(&Connection::CancelInactiveReleaseInloop, this));
    }
    // 切换协议---重置上下文以及阶段性回调处理函数 -- 而是这个接口必须在EventLoop线程中立即执行
    // 防备新的事件触发后，处理的时候，切换任务还没有被执行--会导致数据使用原协议处理了。
    void ChangeProtocl(const Any &context, const ConnectedCallback &conn, const MessageCallback &msg,
                       const ClosedCallback &closed, const AnyEventCallback &event) // 协议切换，重置上下文和业务函数
    {
        _loop->AssertInloop();
        _loop->RunInloop(std::bind(&Connection::ChangeProtoclInlopp, this, context, conn, closed, msg, event));
    }
};
using AcceptCallback = std::function<void(int)>;

class Acceptor
{
private:
    Socket _socket;
    Eventloop *_loop; // 用于对监听套接字进行事件监控
    Channel _channel; // 对监听套接字事件进行管理
    AcceptCallback _acceptcallback;

private:
    void HandleRead()
    {
        int newfd = _socket.Accept();
        if (newfd < 0)
        {
            return;
        }
        if (_acceptcallback)
            _acceptcallback(newfd);
    }
    int CreatServer(int port)
    {
        bool ret = _socket.CreateServer(port);
        if (!ret)
        {
            ERR_LOG("Create acceptserver error");
        }
        return _socket.Fd();
    }
    /*不能将启动读事件监控，放到构造函数中，必须在设置回调函数后，再去启动*/
    /*否则有可能造成启动监控后，立即有事件，处理的时候，回调函数还没设置：新连接得不到处理，且资源泄漏*/
public:
    Acceptor(Eventloop *loop, int port) : _socket(CreatServer(port)), _loop(loop), _channel(_socket.Fd(), _loop)
    {
        _channel.SetReadCallback(std::bind(&Acceptor::HandleRead, this));
        // _channel.EnableRead();
    }
    void SetAcceptCallback(const AcceptCallback &cb) { _acceptcallback = cb; }
    void Listen() { _channel.EnableRead(); }
};
class Tcpserver
{
private:
    uint64_t _port;
    uint64_t _nextid; // 这是一个自动增长的连接ID，
    bool _enable_inactive_release;
    Eventloop _baseloop;                                // 对监听套接字监控s
    Acceptor _acceptor;                                 // 创建监听套接字
    std::unordered_map<uint64_t, PtrConnection> _conns; // 对所有链接监控管理
    ThreadloopPool _pool;                               // loop线程池，对链接进行事件监控处理
    int _timeout;                                       // 这是非活跃连接的统计时间---多长时间无通信就是非活跃连接

    using Functor = std::function<void()>;
    /*这四个回调函数，是让服务器模块来设置的（其实服务器模块的处理回调也是组件使用者设置的）*/
    /*换句话说，这几个回调都是组件使用者使用的*/
    using ConnectedCallback = std::function<void(const PtrConnection &)>;
    using MessageCallback = std::function<void(const PtrConnection &, Buffer *)>;
    using ClosedCallback = std::function<void(const PtrConnection &)>;
    using AnyEventCallback = std::function<void(const PtrConnection &)>;
    ConnectedCallback _connected_callback;
    MessageCallback _message_callback;
    ClosedCallback _closed_callback;
    AnyEventCallback _event_callback;
    /*组件内的连接关闭回调--组件内设置的，因为服务器组件内会把所有的连接管理起来，一旦某个连接要关闭*/
    /*就应该从管理的地方移除掉自己的信息*/
    ClosedCallback _server_closed_callback;

private:
    void RunAfterInloop(const Functor &cb, int delay)
    {
        _nextid++;
        _baseloop.TimerAdd(_nextid, delay, cb);
    }
    void NewConnection(int newfd)
    {
        _nextid++;
        PtrConnection conn(new Connection(_pool.Nextloop(), _nextid, newfd));
        conn->SetMessageCallback(_message_callback);
        conn->SetClosedCallback(_closed_callback);
        conn->SetConnectedCallback(_connected_callback);
        conn->SetAnyEventCallback(_event_callback);
        conn->SetSrvClosedCallback(std::bind(&Tcpserver::RemoveConnection, this, std::placeholders::_1));
        if (_enable_inactive_release)
            conn->EnableInactiveRelease(_timeout); // 启动非活跃超时销毁
        conn->Established();                       // 就绪初始化
        _conns.insert(std::make_pair(_nextid, conn));
        DBG_LOG("NEW ---------------");
    }
    void RemoveConnectionInloop(const PtrConnection &conn)
    {
        auto it = _conns.find(conn->Id());
        if (it != _conns.end())
        {
            _conns.erase(it);
        }
    }
    void RemoveConnection(const PtrConnection &conn)
    {
        return _baseloop.RunInloop(std::bind(&Tcpserver::RemoveConnectionInloop, this, conn));
    }

public:
    Tcpserver(uint64_t port) : _port(port), _nextid(0), _enable_inactive_release(false), _acceptor(&_baseloop, _port), _pool(&_baseloop)
    {
        //  _pool.Create();//在这构造函数先创建0个线程池，会越界
        _acceptor.SetAcceptCallback(std::bind(&Tcpserver::NewConnection, this, std::placeholders::_1));
        _acceptor.Listen();
    }
    void SetThreadCount(int count) { return _pool.SetThreadCount(count); }
    void SetConnectedCallback(const ConnectedCallback &cb) { _connected_callback = cb; }
    void SetMessageCallback(const MessageCallback &cb) { _message_callback = cb; }
    void SetClosedCallback(const ClosedCallback &cb) { _closed_callback = cb; }
    void SetAnyEventCallback(const AnyEventCallback &cb) { _event_callback = cb; }
    void EnableInactiveRelease(int timeout)
    {
        _timeout = timeout;
        _enable_inactive_release = true;
    }
    void Start()
    {
        _pool.Create();
        _baseloop.Start();
    }
    // 用于添加一个定时任务
    void RunAfter(const Functor &task, int delay)
    {
        _baseloop.RunInloop(std::bind(&Tcpserver::RunAfterInloop, this, task, delay));
    }
};
void Channel::Remove() { return _loop->RemoveEvent(this); }
void Channel::Update() { return _loop->UpdateEvent(this); }
void Timewheel::TimerAdd(uint64_t id, int timeout, const TaskFunc &cb)
{
    return _loop->RunInloop(std::bind(&Timewheel::TimeAddInloop, this, id, timeout, cb));
}
void Timewheel::TimerRefresh(uint64_t id)
{
    return _loop->RunInloop(std::bind(&Timewheel::TimeRefreshInloop, this, id));
}
void Timewheel::TimerCancel(uint64_t id)
{
    return _loop->RunInloop(std::bind(&Timewheel::TimeCancelInloop, this, id));
}
// 忽略 SIGPIPE 信号，用于避免程序在特定网络或管道操作中意外退出。进程收到 SIGPIPE 后会直接终止（退出），在很多场景下是不希望发生的（比如网络通信中连接意外断开时）。
class NetWork
{
public:
    NetWork()
    {
        DBG_LOG("SIGPIPE INIT");
        signal(SIGPIPE, SIG_IGN);
    }
};
static NetWork nt;
#endif